Generic Attribute

This paper introduces generic attribute grammars which provide support for genericity, reusability and modularity in attribute grammars. A generic attribute grammar is a component that is easily reused, composed and understood. Attribute grammar based systems may be constructed out of a set of generic components, that can be analysed and compiled separately. We show how to generate deforestated attribute evaluators for those components. As a result, redundant intermediate data structures used to glue diierent components are eliminated. 1. Motivation Recent developments in modern programming languages are providing powerful mechanisms like modularity and polymorphic type systems for abstracting from computations and for structuring programs. Modern applications are nowadays designed and implemented as combinations of several generic components, all physically and conceptually separated from each other. The beneets of such an organization are ease of speciication, clearness of description, interchangeability between diierent plug-compatiblee components, reuse of components across applications and separate analysis/compilation of components. Consider for example the construction of a compiler for a particular language. Such a compiler may be constructed out of a set of generic components, each of which describes a particular subproblem such as name analysis, type checking, register allocation, etc. Furthermore, each component may describe the properties of a subproblem for a large number of languages and not just for the language at hand: a single component may describe the name analysis task for block structured languages. Thus, this oo the shelf component can be re-used across applications. Generally, those components are combined by introducing intermediate data structures that act as the glue, binding the components of the application together: a component constructs (produces) an intermediate data structure which is used (consumed) by other components. In a compiler setting the intermediate structure is the abstract syntax tree which glues the compiler task components. Increasing the number of components means simpler and more modular and maintenable code, whereas decreasing the number of components leads to greater runtime eeciency since fewer intermediate data structures have to be used. The long-sought solution to this tension between modularity and reuse on the one hand, and eeciency on the other, is to increase the amount of analysis and program transformation the compiler is performing so that the programmer may write programs as a set of components, conndent that the compiler can fuse the components together, removing redundant intermediate data structures. 185